Multi-core processing systems may be composed of two or more processors/processor cores capable of operating independently. The multiple processors may be integrated in a single chip. Each processor may have its dedicated memory, while also having access to a shared memory that is shared with other processors. Network interfaces and system bus architectures enable the flow of data between the processors and shared memory structures. A multi-core processing system may also comprise two or more processing environments, wherein each processing environment may include one or more processors and shared memory structures, and the two or more processing environments may be connected through a network.
The processors within the multi-core processing environment may sometimes wish to store data in a local dedicated memory or cache, while also desiring access to the shared memory at other times. However, the multiple processors often wish to appear to users and certain programs as if they are all accessing a unified shared memory. Accordingly, in order to maintain a consistent image of the shared memory, complex cache and memory coherency techniques have been explored in the art. Sometimes cache coherency can be achieved by specialized hardware solutions. In the case of multiple processing environments coupled to a network, distributed shared memory techniques are employed to achieve coherency. The above coherency techniques conventionally involve the migration of blocks of memory from one processing environment to another.
Further, each processor may employ one or more virtual machines. A virtual machine is an abstraction of a processing environment. These virtual machines may be implemented partially or completely in software. There are many applications of virtual machines. For example, a virtual machine may be used to run a software application on a host processor, or to create a virtual environment for running user level programs. Virtual machines are also commonly employed by host processors to run an operating system that is different from the host processor's operating system, or execute an instruction set that is different from that of the host environment. Additionally, virtual machines are used to multiplex many complete processing environments in a single physical machine. Due to the nature of their operation and use, virtual machines are conventionally separated from the physical resources they use, in that they may be dynamically reassigned to a different host or the physical resources within a host may be reassigned between one of several virtual machines running on the host.
In order to maintain cache and memory coherency, the virtual machines may often request data transfers from shared memory residing in processing environments that are separate from the host processor. For example a virtual machine belonging to a host processor in a first processing environment may request data from a shared memory residing in a second processing environment, which results in the movement of large amounts of data across shared network and system bus resources. Moreover, data transfers between processing environments may only be supported in certain minimum transfer sizes. Such minimum transfer sizes may be much larger than the size of data transfer that is required by the virtual machine in the above example. As a result, in multi-core environments with processors supporting a large number of virtual machines, this problem of large blocks of memory being frequently transported on shared system resources can effectively choke the network interfaces and system buses.
The above problem is even more pronounced when it is taken into consideration that the size of the virtual machines themselves are often much smaller than the size of the data transfers initiated by the virtual machines. Accordingly, there is a need in the art for techniques which improve memory coherency while not sacrificing system resources to large data transfers caused by virtual machines.